/*
 * Copyright 2012 Rafael Ferruz
 * 
 * This file is part of CPUZ.
 * 
 * CPUZ is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * CPUZ is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with CPUZ.  If not, see <http://www.gnu.org/licenses/>.
 */
package com.cpuz.filters;

import com.cpuz.exceptions.UserException;
import com.cpuz.tools.CheckTool;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.sql.SQLException;
import java.util.Enumeration;
import javax.naming.NamingException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 *
 * @author RAFAEL FERRUZ
 */
public class UserLogin implements Filter {

	private static final boolean debug = true;
	// The filter configuration object we are associated with.  If
	// this value is null, this filter instance is not currently
	// configured. 
	private FilterConfig filterConfig = null;

	public UserLogin() {
	}

	private void doBeforeProcessing(ServletRequest request, ServletResponse response)
			throws IOException, ServletException {
		if (debug) {
			log("UserLogin:DoBeforeProcessing");
		}

		// Write code here to process the requestáand/or response before
		// the restáof the filter chain is invoked.

		// For example, a logging filter might log items on the requestáobject,
		// such as the parameters.
		for (Enumeration en = request.getParameterNames(); en.hasMoreElements();) {
			String name = (String) en.nextElement();
			String values[] = request.getParameterValues(name);
			int n = values.length;
			StringBuilder buf = new StringBuilder();
			buf.append(name);
			buf.append("=");
			for (int i = 0; i < n; i++) {
				buf.append(values[i]);
				if (i < n - 1) {
					buf.append(",");
				}
			}
			log(buf.toString());
		}
	}

	private void doAfterProcessing(ServletRequest request, ServletResponse response)
			throws IOException, ServletException {
		if (debug) {
			log("UserLogin:DoAfterProcessing");
		}

		// Write code here to process the request and/or response after
		// the restáof the filter chain is invoked.

		// For example, a logging filter might log the attributes on the
		// requestáobject after the requestáhas been processed.
		for (Enumeration en = request.getAttributeNames(); en.hasMoreElements();) {
			String name = (String) en.nextElement();
			Object value = request.getAttribute(name);
			log("attribute: " + name + "=" + value.toString());

		}

		// For example, a filter might append something to the response.
	/*
		PrintWriter respOut = new PrintWriter(response.getWriter());
		respOut.println("<P><B>This has been appended by an intrusive filter.</B>");
		 */
	}

	/**
	 *
	 * @param requestáThe servlet requestáwe are processing
	 * @param response The servlet response we are creating
	 * @param chain The filter chain we are processing
	 *
	 * @exception IOException if an input/output error occurs
	 * @exception ServletException if a servlet error occurs
	 */
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {

		if (debug) {
			log("UserLogin:doFilter()");
		}
		doBeforeProcessing(request, response);

		Throwable problem = null;
		try {
// Comprueba sesión y usuario. Incrementa contador de visitas y comprueba usuario.
			CheckTool.checkSession((HttpServletRequest) request, (HttpServletResponse) response);
			if (this.getFilterConfig().getInitParameter("UserLoginParamName") != null) {
//				if (request.getParameter(this.getFilterConfig().getInitParameter("UserLoginParamName")) != null) {
					CheckTool.checkUserCredentials((HttpServletRequest) request);
//				}
			}
// fin de comprobación de sesión y usuario

			chain.doFilter(request, response);
		} catch (ServletException | IOException | SQLException | UserException | NamingException t ) {
			// If an exception is thrown somewhere down the filter chain,
			// we still want to execute our after processing, and then
			// rethrow the problem after that.
			problem = t;
		}

		doAfterProcessing(request, response);

		// If there was a problem, we want to rethrow it if it is
		// a known type, otherwise log it.
		if (problem != null) {
			if (problem instanceof ServletException) {
				throw (ServletException) problem;
			}
			if (problem instanceof IOException) {
				throw (IOException) problem;
			}
			sendProcessingError(problem, response);
		}
	}

	/**
	 * Return the filter configuration object for this filter.
	 */
	public FilterConfig getFilterConfig() {
		return (this.filterConfig);
	}

	/**
	 * Set the filter configuration object for this filter.
	 *
	 * @param filterConfig The filter configuration object
	 */
	public void setFilterConfig(FilterConfig filterConfig) {
		this.filterConfig = filterConfig;
	}

	/**
	 * Destáoy method for this filter 
	 */
	public void destáoy() {
	}

	/**
	 * Init method for this filter 
	 */
	public void init(FilterConfig filterConfig) {
		this.filterConfig = filterConfig;
		if (filterConfig != null) {
			if (debug) {
				log("UserLogin:Initializing filter");
			}
		}
	}

	/**
	 * Return a String representation of this object.
	 */
	@Override
	public String toString() {
		if (filterConfig == null) {
			return ("UserLogin()");
		}
		StringBuilder sb = new StringBuilder("UserLogin(");
		sb.append(filterConfig);
		sb.append(")");
		return (sb.toString());
	}

	private void sendProcessingError(Throwable t, ServletResponse response) {
		String stackTrace = getStackTrace(t);

		if (stackTrace != null && !stackTrace.equals("")) {
			try {
				response.setContentType("text/html");
				PrintStream ps = new PrintStream(response.getOutputStream());
				PrintWriter pw = new PrintWriter(ps);
				pw.print("<html>\n<head>\n<title>Error</title>\n</head>\n<body>\n"); //NOI18N

				// PENDING! Localize this for next official release
				pw.print("<h1>The resource did not process correctly</h1>\n<pre>\n");
				pw.print(stackTrace);
				pw.print("</pre></body>\n</html>"); //NOI18N
				pw.close();
				ps.close();
				response.getOutputStream().close();
			} catch (Exception ex) {
			}
		} else {
			try {
				PrintStream ps = new PrintStream(response.getOutputStream());
				t.printStackTrace(ps);
				ps.close();
				response.getOutputStream().close();
			} catch (Exception ex) {
			}
		}
	}

	public static String getStackTrace(Throwable t) {
		String stackTrace = null;
		try {
			StringWriter sw = new StringWriter();
			PrintWriter pw = new PrintWriter(sw);
			t.printStackTrace(pw);
			pw.close();
			sw.close();
			stackTrace = sw.getBuffer().toString();
		} catch (Exception ex) {
		}
		return stackTrace;
	}

	public void log(String msg) {
		filterConfig.getServletContext().log(msg);
	}

	@Override
	public void destroy() {
//		throw new UnsupportedOperationException("Not supported yet.");
	}
}
